// 全局变量
let examData = null; // 存储从后端获取的考试数据
let userAnswers = {}; // 存储用户答案（键为"题型-题目ID"）
let currentQuestion = { type: null, index: -1, data: null }; // 当前题目信息
let countdownInterval = null; // 倒计时定时器
let remainingMinutes = 0;
let remainingSeconds = 0;
let isSubmitting = false; // 标记是否正在提交中

// DOM加载完成后初始化
$(document).ready(function() {
    // 初始化弹窗事件
    initModalEvents();

    // 初始化事件监听
    initEventListeners();

    // 从URL获取考试ID
    const urlParams = new URLSearchParams(window.location.search);
    const examId = urlParams.get('id');

    if (!examId) {
        showAlertModal("错误提示", "参数错误，无法加载考试");
        return;
    }

    // 先检查是否已经参加过考试
    checkIfExamined(examId);
});

/**
 * 检查是否已经参加过考试
 */
function checkIfExamined(examId) {
    if (!examId || isNaN(examId)) {
        showAlertModal("错误", "考试ID无效");
        return;
    }

    $.ajax({
        url: '/studentexam/ifnot',
        type: 'GET',
        data: { examId: examId },
        success: function(response) {
            if (response.code === "0000") {  // 只要接口调用成功
                if (response.data) {
                    // data不为null → 已参加考试
                    showAlertModal("提示", "您已参加过该考试，无法再次进入", function() {
                        window.location.href = "/LLMTchStd/examsystem";
                    });
                } else {
                    // data为null → 未参加考试，继续新增记录
                    insertExamRecord(examId);
                }
            } else {
                // 真正的错误（如未登录、参数错误等）
                showAlertModal("错误", response.msg || "查询失败");
            }
        },
        error: function(xhr) {
            showAlertModal("网络错误", "请求失败：" + xhr.statusText);
        }
    });
}
/**
 * 新增考试记录
 */
function insertExamRecord(examId) {
    // 构造请求数据
    const requestData = {
        examId: examId
        // 不需要传递studentId，后端会从session获取
    };

    $.ajax({
        url: '/studentexam/insertone',
        type: 'POST',
        contentType: 'application/json',
        data: JSON.stringify(requestData),
        success: function(response) {
            if (response.code === "0000" && response.data) {
                // 新增记录成功，加载考试数据
                fetchExamData(examId);
            } else {
                showAlertModal("操作失败", response.msg || "无法开始考试，请稍后再试");
            }
        },
        error: function() {
            showAlertModal("网络错误", "无法连接到服务器，无法开始考试");
        }
    });
}

/**
 * 初始化弹窗事件
 */
function initModalEvents() {
    // 通用关闭按钮事件
    $('.close-modal').click(function() {
        $(this).closest('.modal').removeClass('show');
    });

    // 点击弹窗外部关闭
    $(document).click(function(e) {
        if ($(e.target).hasClass('modal')) {
            $(e.target).removeClass('show');
        }
    });
}

/**
 * 显示提示弹窗
 * @param {string} title 标题
 * @param {string} message 内容
 * @param {function} callback 确定后的回调函数
 */
function showAlertModal(title, message, callback) {
    const modal = $('#alertModal');
    $('#alertTitle').text(title);
    $('#alertMessage').text(message);
    modal.addClass('show');

    // 移除之前的事件绑定，避免多次触发
    const confirmBtn = $('#confirmAlertBtn');
    confirmBtn.off('click');

    // 绑定确认按钮事件
    confirmBtn.click(function() {
        modal.removeClass('show');
        if (typeof callback === 'function') {
            callback();
        }
    });
}

/**
 * 从后端获取考试数据
 */
function fetchExamData(examId) {
    $.ajax({
        url: `/studentexam/selectone?id=${examId}`,
        type: 'GET',
        dataType: 'json',
        success: function(response) {
            if (response.code === "0000" && response.data) {
                examData = response.data;
                console.log(examData)
                // 初始化考试页面
                initExamPage();
            } else {
                showAlertModal("获取失败", "获取考试数据失败：" + (response.msg || "未知错误"));
            }
        },
        error: function() {
            showAlertModal("网络错误", "网络错误，无法连接到服务器");
        }
    });
}

/**
 * 初始化考试页面
 */
function initExamPage() {
    // 初始化考试信息
    initExamInfo();

    // 初始化题目导航
    initQuestionNavigation();

    // 开始倒计时（基于发布时间和考试时长动态计算）
    startCountdown();

    // 默认显示第一题
    showFirstQuestion();
}

/**
 * 初始化考试基本信息
 */
function initExamInfo() {
    $("#examName").text(examData.examName || "未知考试");
    // 显示考试描述（如果有）
    if (examData.description) {
        $("#examDescription").text(examData.description).show();
    }
}

/**
 * 初始化题目导航
 */
function initQuestionNavigation() {
    // 题型映射关系 - 对应后端返回的字段
    const questionTypes = [
        { type: 'choice', label: '选择题', field: 'choiceQuestions' },
        { type: 'fill', label: '填空题', field: 'fillQuestions' },
        { type: 'judge', label: '判断题', field: 'judgeQuestions' },
        { type: 'essay', label: '主观题', field: 'essayQuestions' },
        { type: 'calculate', label: '计算题', field: 'calculateQuestions' }
    ];

    // 为每种题型生成题目导航
    questionTypes.forEach(item => {
        // 解析JSON字符串为数组
        let questions = [];
        try {
            questions = examData[item.field] ? JSON.parse(examData[item.field]) : [];
        } catch (e) {
            console.error(`解析${item.label}失败:`, e);
            questions = [];
        }

        const container = $(`#${item.type}QuestionNumbers`);
        const typeNav = $(`#${item.type}QuestionsNav`);

        // 清空容器
        container.empty();

        // 如果该题型没有题目，则隐藏
        if (!questions || questions.length === 0) {
            typeNav.hide();
            return;
        }

        // 显示题型导航
        typeNav.show();
        typeNav.find('h3').text(`${item.label} (${questions.length}题)`);

        // 生成题目编号方块
        questions.forEach((question, index) => {
            const questionNumber = $('<div>')
                .addClass('question-number')
                .text(question.id)
                .attr('data-type', item.type)
                .attr('data-index', index);

            questionNumber.click(function() {
                const type = $(this).attr('data-type');
                const index = parseInt($(this).attr('data-index'));
                showQuestion(type, index);
            });

            container.append(questionNumber);
        });
    });
}

/**
 * 显示第一题
 */
function showFirstQuestion() {
    const types = ['choice', 'fill', 'judge', 'essay', 'calculate'];
    for (let type of types) {
        const questions = getQuestionsByType(type);
        if (questions && questions.length > 0) {
            showQuestion(type, 0);
            return;
        }
    }
}

/**
 * 根据题型获取题目列表
 */
function getQuestionsByType(type) {
    // 映射题型到后端字段
    const fieldMap = {
        'choice': 'choiceQuestions',
        'fill': 'fillQuestions',
        'judge': 'judgeQuestions',
        'essay': 'essayQuestions',
        'calculate': 'calculateQuestions'
    };

    const field = fieldMap[type];
    if (!field || !examData[field]) return [];

    try {
        return JSON.parse(examData[field]);
    } catch (e) {
        console.error(`获取${type}题目失败:`, e);
        return [];
    }
}

/**
 * 显示指定题目
 */
function showQuestion(type, index) {
    const questions = getQuestionsByType(type);
    if (!questions || index < 0 || index >= questions.length) return;

    // 更新当前题目信息
    currentQuestion.type = type;
    currentQuestion.index = index;
    currentQuestion.data = questions[index];

    // 移除之前的激活状态
    $('.question-number.active').removeClass('active');

    // 添加当前激活状态
    $(`.question-number[data-type="${type}"][data-index="${index}"]`).addClass('active');

    // 更新题目标题和分值
    $('#currentQuestionTitle').text(`${getQuestionTypeName(type)} ${currentQuestion.data.id}`);
    $('#currentQuestionScore').text(`分值：${currentQuestion.data.score || 0}分`);

    // 更新题目内容
    $('#currentQuestionContent').html(currentQuestion.data.content);

    // 根据题型生成不同的答题区域
    const answerContainer = $('#currentQuestionAnswer');
    answerContainer.empty();

    switch(type) {
        case 'choice':
            renderChoiceQuestion(answerContainer, currentQuestion.data);
            break;
        case 'fill':
            renderFillQuestion(answerContainer);
            break;
        case 'judge':
            renderJudgeQuestion(answerContainer);
            break;
        case 'essay':
        case 'calculate':
            renderTextAnswerQuestion(answerContainer, type);
            break;
    }

    // 加载已保存的答案（传递题型和题目ID）
    loadSavedAnswer(type, currentQuestion.data.id);
}

/**
 * 渲染选择题
 */
function renderChoiceQuestion(container, question) {
    const optionsContainer = $('<div>').addClass('question-options');
    const type = 'choice'; // 当前题型

    if (question.options && question.options.length > 0) {
        question.options.forEach(option => {
            const optionDiv = $('<div>').addClass('option');
            const optionId = `option-${question.id}-${option.charAt(0)}`;

            const radio = $('<input>')
                .attr('type', 'radio')
                .attr('id', optionId)
                .attr('name', `question-${type}-${question.id}`)
                .attr('value', option.charAt(0));

            const label = $('<label>')
                .attr('for', optionId)
                .addClass('option-label')
                .text(option);

            optionDiv.append(radio).append(label);
            optionsContainer.append(optionDiv);

            // 添加选项点击事件
            optionDiv.click(function() {
                radio.prop('checked', true);
                saveAnswer(type, question.id, radio.val());

                // 更新选项选中状态
                $('.option').removeClass('selected');
                optionDiv.addClass('selected');
            });
        });
    }

    container.append(optionsContainer);
}

/**
 * 渲染填空题
 */
function renderFillQuestion(container) {
    const type = currentQuestion.type; // 当前题型
    const questionId = currentQuestion.data.id; // 当前题目ID

    const input = $('<input>')
        .addClass('form-control')
        .attr('placeholder', '请输入答案')
        .keyup(function() {
            // 传递题型、题目ID和答案
            saveAnswer(type, questionId, $(this).val());
        });

    container.append(input);
}

/**
 * 渲染判断题
 */
function renderJudgeQuestion(container) {
    const type = 'judge'; // 当前题型
    const questionId = currentQuestion.data.id; // 当前题目ID

    const optionsContainer = $('<div>').addClass('question-options');

    const options = [
        { value: 'true', text: '正确' },
        { value: 'false', text: '错误' }
    ];

    options.forEach(option => {
        const optionDiv = $('<div>').addClass('option');
        const optionId = `judge-${questionId}-${option.value}`;

        const radio = $('<input>')
            .attr('type', 'radio')
            .attr('id', optionId)
            .attr('name', `question-${type}-${questionId}`)
            .attr('value', option.value);

        const label = $('<label>')
            .attr('for', optionId)
            .addClass('option-label')
            .text(option.text);

        optionDiv.append(radio).append(label);
        optionsContainer.append(optionDiv);

        // 添加选项点击事件
        optionDiv.click(function() {
            radio.prop('checked', true);
            saveAnswer(type, questionId, radio.val());

            // 更新选项选中状态
            $('.option').removeClass('selected');
            optionDiv.addClass('selected');
        });
    });

    container.append(optionsContainer);
}

/**
 * 渲染主观题和计算题（文本输入）
 */
function renderTextAnswerQuestion(container, type) {
    const questionId = currentQuestion.data.id; // 当前题目ID

    const textarea = $('<textarea>')
        .addClass('form-control')
        .attr('placeholder', type === 'essay' ? '请输入您的答案' : '请输入计算过程和结果')
        .attr('rows', 6)
        .keyup(function() {
            // 传递题型、题目ID和答案
            saveAnswer(type, questionId, $(this).val());
        });

    container.append(textarea);
}

/**
 * 保存答案（使用“题型-题目ID”作为唯一键）
 */
function saveAnswer(type, questionId, answer) {
    const uniqueKey = `${type}-${questionId}`; // 生成唯一键（如"choice-1"）
    userAnswers[uniqueKey] = answer;

    // 更新题目状态为已答
    $(`.question-number[data-type="${type}"][data-index="${currentQuestion.index}"]`)
        .addClass('answered');
}

/**
 * 加载已保存的答案（使用“题型-题目ID”作为唯一键）
 */
function loadSavedAnswer(type, questionId) {
    const uniqueKey = `${type}-${questionId}`; // 对应保存时的唯一键
    const answer = userAnswers[uniqueKey];
    if (!answer) return;

    switch(type) {
        case 'choice':
        case 'judge':
            $(`input[name="question-${type}-${questionId}"][value="${answer}"]`).prop('checked', true);
            $(`input[name="question-${type}-${questionId}"][value="${answer}"]`).closest('.option').addClass('selected');
            break;
        case 'fill':
        case 'essay':
        case 'calculate':
            $('#currentQuestionAnswer .form-control').val(answer);
            break;
    }
}

/**
 * 获取题型名称
 */
function getQuestionTypeName(type) {
    const typeNames = {
        'choice': '选择题',
        'fill': '填空题',
        'judge': '判断题',
        'essay': '主观题',
        'calculate': '计算题'
    };
    return typeNames[type] || '';
}

/**
 * 切换到上一题
 */
function prevQuestion() {
    if (!currentQuestion.type || currentQuestion.index <= 0) return;

    showQuestion(currentQuestion.type, currentQuestion.index - 1);
    scrollToCurrentQuestion();
}

/**
 * 切换到下一题
 */
function nextQuestion() {
    if (!currentQuestion.type) return;

    const questions = getQuestionsByType(currentQuestion.type);
    if (currentQuestion.index >= questions.length - 1) {
        // 如果是当前题型的最后一题，尝试切换到下一种题型
        const types = ['choice', 'fill', 'judge', 'essay', 'calculate'];
        const currentTypeIndex = types.indexOf(currentQuestion.type);

        for (let i = currentTypeIndex + 1; i < types.length; i++) {
            const nextType = types[i];
            const nextTypeQuestions = getQuestionsByType(nextType);
            if (nextTypeQuestions && nextTypeQuestions.length > 0) {
                showQuestion(nextType, 0);
                scrollToCurrentQuestion();
                return;
            }
        }
    } else {
        showQuestion(currentQuestion.type, currentQuestion.index + 1);
        scrollToCurrentQuestion();
    }
}

/**
 * 滚动到当前题目导航位置
 */
function scrollToCurrentQuestion() {
    const activeQuestion = $('.question-number.active');
    if (activeQuestion.length) {
        const navContainer = $('#questionNav');
        navContainer.scrollTop(
            activeQuestion.offset().top - navContainer.offset().top + navContainer.scrollTop() - 50
        );
    }
}

/**
 * 开始倒计时（基于发布时间和考试时长动态计算）
 */
function startCountdown() {
    // 清除已有定时器
    if (countdownInterval) {
        clearInterval(countdownInterval);
    }

    // 从考试数据中获取关键信息（发布时间、时长）
    const releaseTimeStr = examData.releaseTime;
    const examDurationMin = parseInt(examData.examDuration) || 0;

    // 校验发布时间是否有效
    if (!releaseTimeStr) {
        showAlertModal("参数错误", "考试发布时间未设置，无法启动倒计时");
        return;
    }

    // 转换发布时间为时间戳（毫秒）
    const releaseTimeStamp = new Date(releaseTimeStr).getTime();
    // 计算考试结束时间戳（发布时间 + 时长分钟）
    const endTimeStamp = releaseTimeStamp + examDurationMin * 60 * 1000;

    // 定时器：每秒更新一次剩余时间
    countdownInterval = setInterval(function() {
        const nowTimeStamp = new Date().getTime(); // 当前时间戳
        let remainingMs = 0; // 剩余时间（毫秒）

        // 1. 考试未开始：剩余时间 = 发布时间 - 当前时间
        if (nowTimeStamp < releaseTimeStamp) {
            remainingMs = releaseTimeStamp - nowTimeStamp;
        }
        // 2. 考试进行中：剩余时间 = 结束时间 - 当前时间
        else if (nowTimeStamp <= endTimeStamp) {
            remainingMs = endTimeStamp - nowTimeStamp;
        }
        // 3. 考试已结束：剩余时间为0
        else {
            remainingMs = 0;
        }

        // 转换剩余毫秒为 分:秒
        const totalSeconds = Math.floor(remainingMs / 1000);
        remainingMinutes = Math.floor(totalSeconds / 60);
        remainingSeconds = totalSeconds % 60;

        // 更新显示
        updateTimerDisplay();

        // 处理时间到的情况
        if (remainingMs <= 0) {
            clearInterval(countdownInterval);
            timeUp();
        }

        // 剩余5分钟内添加警告样式（仅考试进行中生效）
        if (nowTimeStamp >= releaseTimeStamp && nowTimeStamp <= endTimeStamp && remainingMinutes < 5) {
            $('#timer').addClass('warning');
        } else {
            $('#timer').removeClass('warning');
        }
    }, 1000);

    // 初始化显示
    updateTimerDisplay();
}

/**
 * 更新计时器显示
 */
function updateTimerDisplay() {
    const minutes = String(remainingMinutes).padStart(2, '0');
    const seconds = String(remainingSeconds).padStart(2, '0');
    $('#timer').text(`${minutes}:${seconds}`);
}

/**
 * 时间到处理函数
 */
function timeUp() {
    // 如果正在提交中，不重复处理
    if (isSubmitting) return;

    $('#timeUpModal').addClass('show');
    // 自动提交答案
    submitExam(true);
}

// 提交试卷
function submitExam(isAuto = false) {
    // 防止重复提交
    if (isSubmitting) return;

    if (!examData || !examData.examId) {
        showAlertModal("提交失败", "考试信息错误，无法提交");
        return;
    }

    // 标记为正在提交
    isSubmitting = true;

    // 显示判卷中提示弹窗
    $('#judgingModal').addClass('show');

    // 隐藏交卷确认弹窗（如果显示中）
    $('#submitModal').removeClass('show');

    // 禁用交卷按钮
    $('#submitBtn').prop('disabled', true).css('opacity', '0.6');

    // 提交的数据中保持"题型-题目ID"的键结构
    const submitData = {
        examId: examData.examId,
        answer: JSON.stringify(userAnswers), // 存储的是带题型前缀的键值对
        // submitTime: new Date().toLocaleString()
    };

    // 发送答案到后端
    $.ajax({
        url: '/studentexam/save',
        type: 'POST',
        contentType: 'application/json',
        data: JSON.stringify(submitData),
        success: function(response) {
            // 重置提交状态
            isSubmitting = false;
            // 隐藏判卷提示弹窗
            $('#judgingModal').removeClass('show');

            if (response.code === "0000") {
                // 获取分数（假设后端返回的data中包含score字段）
                console.log(response.data.score)
                const score = response.data.score || 0;

                // 先刷新页面，再跳转（添加刷新逻辑）
                showAlertModal("提交成功", `考试提交成功！您的得分是：${score}分`, function() {
                    // 刷新当前页面
                    window.location.reload(true);
                    // 刷新后跳转（如果刷新后未自动跳转，可保留此逻辑）
                    setTimeout(() => {
                        window.location.href = `/LLMTchStd/studentview`;
                    }, 1000);
                });
            } else {
                // 提交失败时重新启用交卷按钮
                $('#submitBtn').prop('disabled', false).css('opacity', '1');
                showAlertModal("提交失败", '提交失败：' + (response.msg || "未知错误"));
            }
        },
        error: function() {
            // 重置提交状态
            isSubmitting = false;
            // 隐藏判卷提示弹窗
            $('#judgingModal').removeClass('show');
            // 提交失败时重新启用交卷按钮
            $('#submitBtn').prop('disabled', false).css('opacity', '1');
            showAlertModal("提交失败", "提交失败，请检查网络连接");
        }
    });
}

/**
 * 初始化事件监听
 */
function initEventListeners() {
    // 上一题/下一题按钮
    $('#prevQuestionBtn').click(prevQuestion);
    $('#nextQuestionBtn').click(nextQuestion);

    // 交卷按钮
    $('#submitBtn').click(function() {
        // 如果正在提交中，不执行操作
        if (isSubmitting) return;
        $('#submitModal').addClass('show');
    });

    // 关闭交卷弹窗
    $('#closeSubmitModal, #cancelSubmitBtn').click(function() {
        $('#submitModal').removeClass('show');
    });

    // 确认交卷
    $('#confirmSubmitBtn').click(function() {
        submitExam();
    });

    // 时间到确认按钮
    $('#confirmTimeUpBtn').click(function() {
        $('#timeUpModal').removeClass('show');
    });

    // 键盘导航支持
    $(document).keydown(function(e) {
        // 左箭头键 - 上一题
        if (e.keyCode === 37) {
            prevQuestion();
        }
        // 右箭头键 - 下一题
        else if (e.keyCode === 39) {
            nextQuestion();
        }
    });
}